package org.javahispano.javacup.tacticas_aceptadas.capello;
import org.javahispano.javacup.modelo.*;

import java.util.LinkedList;
import java.util.List;


public class capello_team implements Tactica {
	//inf importante:
	// mi portero es el jugador 10
	 private double posAntX,posAntY,posAntZ=0;
	 private double balonDx,balonDy,balonDz=0;
	 private int porteroContrario=0;
	 private boolean paseDelantero=false;
	 private double itPaseDelantero=0;
	 
 	 private double ballX,ballY,ballZ,ballZAnterior,ballDx,ballDy,ballDz=0;

 	 private int anteriorJugTocarBola=10;
 	 public int golesMios=0;
 	 public double [] misGoleadores={0,0,0,0,0,0,0,0,0,0,0};
 	 
 	capello_teamDetalle detalle = new capello_teamDetalle();
 	 Posicion alineacion1[]=new Posicion[]{ //ALINEACION NORMAL
 			new Posicion(7,27), //delantero derecha,
 	        new Posicion(-6,-26), //central izq
 	        new Posicion(0,40), // delantero centro
 	        new Posicion(6,-26), //central derecho
 	        new Posicion(6,-4),//medio derecho
 	        new Posicion(-6,-4), //medio izquierdo
 	        new Posicion(-20,3), // interior izquierdo
 	        new Posicion(20,3),  //interior derecho
 	        new Posicion(-7,27), // delantero izquierdo
 	        new Posicion(-3,12), //media punta
 	        new Posicion(0,-52) // portero
 	        
 	    };

 	    Posicion alineacion2[]=new Posicion[]{ //ALINEACION CUANDO SAKO DE CENTRO
 	 			new Posicion(3,32), //delantero derecha,
 	 	        new Posicion(-6,-26), //central izq
 	 	        new Posicion(0,40), // delantero centro
 	 	        new Posicion(6,-26), //central derecho
 	 	        new Posicion(6,-16),//medio derecho
 	 	        new Posicion(-6,-16), //medio izquierdo
 	 	        new Posicion(-20,-10), // interior izquierdo
 	 	        new Posicion(20,-10),  //interior derecho
 	 	        new Posicion(-11,-27), // delantero izquierdo
 	 	        new Posicion(-3,12), //media punta
 	 	        new Posicion(0,-52) // portero
 	    };

 	    Posicion alineacion3[]=new Posicion[]{  //ALINEACION CUANDO �L SAKA DE CENTRO
 	    		new Posicion(3,32), //delantero derecha,
 	 	        new Posicion(-6,-26), //central izq
 	 	        new Posicion(0,40), // delantero centro
 	 	        new Posicion(6,-26), //central derecho
 	 	        new Posicion(6,-16),//medio derecho
 	 	        new Posicion(-6,-16), //medio izquierdo
 	 	        new Posicion(-20,-10), // interior izquierdo
 	 	        new Posicion(20,-10),  //interior derecho
 	 	        new Posicion(-11,27), // delantero izquierdo
 	 	        new Posicion(-3,12), //media punta
 	 	        new Posicion(0,-52) // portero
 	    };

 	    Posicion alineacion4[]=new Posicion[]{
 	 			new Posicion(3,32), //delantero derecha,
 	 	        new Posicion(-6,-26), //central izq
 	 	        new Posicion(0,40), // delantero centro
 	 	        new Posicion(6,-26), //central derecho
 	 	        new Posicion(6,-4),//medio derecho
 	 	        new Posicion(-6,-4), //medio izquierdo
 	 	        new Posicion(-20,3), // interior izquierdo
 	 	        new Posicion(20,3),  //interior derecho
 	 	        new Posicion(-11,27), // delantero izquierdo
 	 	        new Posicion(-3,12), //media punta
 	 	        new Posicion(0,-52) // portero
 	    };

 	    Posicion alineacion5[]=new Posicion[]{
 	 			new Posicion(3,32), //delantero derecha,
 	 	        new Posicion(-6,-26), //central izq
 	 	        new Posicion(0,40), // delantero centro
 	 	        new Posicion(6,-26), //central derecho
 	 	        new Posicion(6,-4),//medio derecho
 	 	        new Posicion(-6,-4), //medio izquierdo
 	 	        new Posicion(-20,3), // interior izquierdo
 	 	        new Posicion(20,3),  //interior derecho
 	 	        new Posicion(-11,27), // delantero izquierdo
 	 	        new Posicion(-3,12), //media punta
 	 	        new Posicion(0,-52) // portero
 	    };

 	    Posicion alineacion6[]=new Posicion[]{
 	 			new Posicion(3,32), //delantero derecha,
 	 	        new Posicion(-6,-26), //central izq
 	 	        new Posicion(0,40), // delantero centro
 	 	        new Posicion(6,-26), //central derecho
 	 	        new Posicion(6,-4),//medio derecho
 	 	        new Posicion(-6,-4), //medio izquierdo
 	 	        new Posicion(-20,3), // interior izquierdo
 	 	        new Posicion(20,3),  //interior derecho
 	 	        new Posicion(-11,27), // delantero izquierdo
 	 	        new Posicion(-3,12), //media punta
 	 	        new Posicion(0,-52) // portero
 	    };


    public TacticaDetalle getDetalle() {
        return detalle;
    }

    public Posicion[] getPosicionSaca(SituacionPartido sp) {

    return alineacion2;
    }

    public Posicion[] getPosicionRecive(SituacionPartido sp) {

    return alineacion3;
    }
   
    

int cont1=0;

    LinkedList<Comando> comandos = new LinkedList<Comando>();
    public List<Comando> ejecutar(SituacionPartido sp) {
    	Posicion posAux=new Posicion(0,52);
    	this.porteroContrario=posAux.indiceMasCercano(sp.rivales());
    	 //vacia la lista de comandos
        comandos.clear();

        if (sp.golesPropios()>this.golesMios)
        {
        	this.misGoleadores[this.anteriorJugTocarBola]++;
        	this.golesMios=sp.golesPropios();
       	
        }
        
        if (sp.puedenRematar().length>0)
        {
        	this.anteriorJugTocarBola=sp.puedenRematar()[0];   	
        }       
        
      
        if (paseDelantero && (sp.iteracion()-this.itPaseDelantero>45))
        {
        	paseDelantero=false;
        }
        
        this.balonDx=sp.balon().getX()-this.posAntX;
        this.balonDy=sp.balon().getY()-this.posAntY;
        this.balonDz=sp.alturaBalon()-this.posAntZ;
        
        moverJugadoresEnFuncionBalon(sp,comandos);
        
        int[] jugadoresPuedenRematar= sp.puedenRematar();
        if (jugadoresPuedenRematar.length>0)
        {
        	int jugRem=jugadoresPuedenRematar[0];
        	if(jugRem==10)
        	{
        		paseDePortero(sp);
        	}
        	else
        	{

        		if (condicionesTirarPorteria(jugRem,sp))
        		{
        			tiroAjustadoPorteria(jugRem,sp);
        		}
        		else if  (jugRem==1 || jugRem==3)
        		{
        			paseDeDefensa(jugRem,sp);
        		}
        		else
        		{
        			int jugPaseClaro;
            		int []jugsAPasar={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
            		jugsAPasar=getJugsPorDelante(jugRem,10,sp);
            		jugPaseClaro=buscarPaseClaro(jugRem,jugsAPasar,sp);
            		if (jugPaseClaro!=-1)
            		{
            			comandos.add(new ComandoGolpearBalon(jugRem,sp.misJugadores()[jugPaseClaro],1,false));
            		}
            		else if (puedoLlevarBalon(jugRem,sp) )
                	{
            			
                		comandos.add(new ComandoGolpearBalon(jugRem));
                		comandos.add(new ComandoIrA(jugRem,new Posicion(0,52.5)));
                	}
            		else
            		{
            			jugsAPasar=getJugsPorDelante(jugRem,10,sp);
            			jugPaseClaro=buscarPaseClaro(jugRem,jugsAPasar,sp);
            			
            			if (jugPaseClaro!=-1)
                		{
                			comandos.add(new ComandoGolpearBalon(jugRem,sp.misJugadores()[jugPaseClaro],1,false));
                		}
            			else
            			{
            				
            				int delanteroPasar=buscarDelanteroPasar(jugRem,sp);
            			
            				if (delanteroPasar!=-1)
            				{
            					if (sp.balon().getY()>20)
            					{
                					Posicion posPaseDelantero=new Posicion(sp.misJugadores()[delanteroPasar].getX(),sp.misJugadores()[delanteroPasar].getY());
                   					comandos.add(new ComandoGolpearBalon(jugRem,posPaseDelantero,1,false));
            					}
            					else
            					{
                					Posicion posPaseDelantero=new Posicion(sp.misJugadores()[delanteroPasar].getX(),sp.misJugadores()[delanteroPasar].getY());
                       				double mejorAnguloVertical=mejorAnguloVertical(jugRem,posPaseDelantero,sp);
                   					comandos.add(new ComandoGolpearBalon(jugRem,posPaseDelantero,1,mejorAnguloVertical));
            					}

            				}
            				else
            				{
            					
            					Posicion [] posicionesJugadores=sp.misJugadores();
                       			
                       			int jugPase=-1;
                       			double distMaxima=0;
                       			for(int i=0;i<10;i++)
                       			{
                       				double dist=posicionesJugadores[jugRem].distancia(posicionesJugadores[i]);
                       				if (dist<25 && i!=jugRem && posicionesJugadores[jugRem].getY()<posicionesJugadores[i].getY()+3)
                       				{
                       					double distContrario=400;
                       					for(int j=0;j<10;j++)
                       					{
                       						if (posicionesJugadores[i].distancia(sp.rivales()[j])<distContrario)
                       						{
                       							distContrario=posicionesJugadores[i].distancia(sp.rivales()[j]);
                       						}
                       					}
                       					if (distContrario>distMaxima)
                       					{
                       						distMaxima=distContrario;
                       						jugPase=i;
                       					}
                       					
                       				}
                       				
                       			}
                       			if (jugPase!=-1)
                       			{
                       				
                       				double mejorAnguloVertical=mejorAnguloVertical(jugRem,posicionesJugadores[jugPase],sp);
                       				if ( (jugPase==6 && sp.misJugadores()[6].getX()>29) || (jugPase==7 && sp.misJugadores()[7].getX()<-29))
                       				{
                       					comandos.add(new ComandoGolpearBalon(jugRem,posicionesJugadores[jugPase],0.85,mejorAnguloVertical));
                       				}
                       				else
                       				{
                       					comandos.add(new ComandoGolpearBalon(jugRem,posicionesJugadores[jugPase],1,mejorAnguloVertical));
                       				}
                       				
                       			}
                       			else
                       			{
                       				tiroAjustadoPorteria(jugRem,sp);
                       			}
            				}
            				
            			}
            		}
        		}
        	}
        	
        	if (sp.balon().getX()==0 && sp.balon().getY()==0)//si el balon esta en el centro del campo (saque de centro) nos olvidamos de lo anterior y que tire para adelante
        	{
				comandos.add(new ComandoGolpearBalon(jugRem,new Posicion (0,53),1,45));
        	}
       	}
        else
        {
        	int numJugador=this.moverJugadorAlBalon(sp);
        	ballY=this.control(ballY, -52.1, 52);
        	ballX=this.control(ballX, -34, 34);
        	if (numJugador==10)
        	{
        		ballX=this.control(ballX, (-Constantes.LARGO_ARCO/2)+0.5, (Constantes.LARGO_ARCO/2)-0.5);
        		comandos.add(new ComandoIrA(numJugador,new Posicion(ballX,ballY)));
        	}
        	else
        	{
        		comandos.add(new ComandoIrA(numJugador,new Posicion(ballX,ballY)));	
        		
        		if (sp.balon().getY()<-44 && sp.balon().getX()>-13 && sp.balon().getY()<13)
        		{
        			ballX=this.control(ballX, (-Constantes.LARGO_ARCO/2)+0.5, (Constantes.LARGO_ARCO/2)-0.5);
        			comandos.add(new ComandoIrA(10,new Posicion(ballX,ballY)));
        		}
        		
        	}
        	
        }
           
        this.posAntX=sp.balon().getX();
        this.posAntY=sp.balon().getY();
        this.posAntZ=sp.alturaBalon();
        //retorna la lista de comandos.
       
        return comandos;
    }
    
    private int buscarDelanteroPasar(int jugRem,SituacionPartido sp)
    {
    	int delantero=-1;
    	double distAl0=sp.balon().distancia(sp.misJugadores()[0]);
    	double distAl8=sp.balon().distancia(sp.misJugadores()[8]);
    	double distAl2=sp.balon().distancia(sp.misJugadores()[2]);
    	
    	if (jugRem==0)
    	{
    		if (distAl8<23 || distAl2<23)
        	{
        		delantero=sp.balon().indiceMasCercano(sp.misJugadores(),0,1,3,4,5,6,7,9,10);
        	}
    	}
    	else if( jugRem==8)
    	{
    		if (distAl0<23 || distAl2<23)
        	{
        		delantero=sp.balon().indiceMasCercano(sp.misJugadores(),1,3,4,5,6,7,8,9,10);
        	}
    	}
    	else if (jugRem==2)
    	{
    		if (distAl0<23 || distAl8<23)
        	{
        		delantero=sp.balon().indiceMasCercano(sp.misJugadores(),1,2,3,4,5,6,7,9,10);
        	}
    	}
    	else
    	{
        	if (distAl0<23 || distAl8<23 || distAl2<23)
        	{
        		delantero=sp.balon().indiceMasCercano(sp.misJugadores(),1,3,4,5,6,7,9,10);
        	}
    	}
    	
    	if (jugRem!=2 && delantero !=-1)
    	{
    		if (sp.misJugadores()[jugRem].distancia(sp.misJugadores()[2])<30)
    		{
    			delantero=2;
    		}
    	}
    	else if (delantero==-1 && distAl2<30)
    	{
    		delantero=2;
    	}

    return delantero;
    }
    private boolean condicionesTirarPorteria(int jugRem,SituacionPartido sp)
    {
    	boolean tirar=false;
    	if (sp.balon().getY()>36.5 && sp.balon().getX()<15 && sp.balon().getX()>-15)
    	{
    		tirar=true;
    	}
    	else if (sp.balon().getY()>34 && sp.balon().getX()<17 && sp.balon().getX()>-17)
    	{
    		boolean otroJugPasar=false;
    		for(int i=0;i<10 && !otroJugPasar;i++)
    		{
    			if (i!=jugRem)
    			{
    				if (sp.misJugadores()[i].getY()+1>sp.misJugadores()[jugRem].getY())
    				{
    					otroJugPasar=true;    					
    				}
    				else
    				{
    					tirar=true;
    				}
    			}
    		}
    	}
    	
    return tirar;
    }
    
    private double mejorAnguloVertical(int jugRem,Posicion posFinal,SituacionPartido sp)
    {
    	double angConvert=Math.PI / 180d;
    	double mejorAnguloVertical=-1;
    	double mejorDistInicioFinalPredecido=-20;
    	double angVer=1;
    	double angulo=sp.balon().angulo(posFinal)*angConvert;
    	double vel=Constantes.getVelocidadRemate(sp.detalleMisJugadores()[jugRem].getRemate());
    	angVer = angVer * angConvert;
    	boolean salir=false;
    	double distInicioFinal=posFinal.distancia(sp.balon());
        
    	
    	double dZ;
        double dX;
        double dY;
        double z;
        double x;
        double y;
        double distInicioFinalPredecido;
       for (angVer=1;angVer<=60 && !salir;angVer++)
       {
    	   dZ=redondeaMultiplo(vel * Math.sin(angVer), Constantes.G);
           dX=Math.cos(angulo) * vel;
           dY=Math.sin(angulo) * vel;
           z=0+dZ;
           x=sp.balon().getX()+dX;
           y=sp.balon().getY()+dY;
           distInicioFinalPredecido=sp.balon().distancia(new Posicion(x,y)); 
           
           while(distInicioFinal>distInicioFinalPredecido && z>0.5)
           {
           	dZ = redondeaMultiplo(dZ - Constantes.G, Constantes.G);
           	dX = dX * Constantes.FACTOR_DISMINUCION_VEL_BALON_AIRE;
           	dY = dY * Constantes.FACTOR_DISMINUCION_VEL_BALON_AIRE;
           	z=z+dZ;
            x=x+dX;
            y=y+dY;
           distInicioFinalPredecido=sp.balon().distancia(new Posicion(x,y));
           }
           if (distInicioFinal<distInicioFinalPredecido)
           {
           	if (z<Constantes.ALTURA_CONTROL_BALON)
           	{
           		salir=true;
           		mejorAnguloVertical=angVer;
           	}     	
           }
           else
           {
           	if(distInicioFinalPredecido>mejorDistInicioFinalPredecido)
           	{
           		mejorAnguloVertical=angVer;
           		mejorDistInicioFinalPredecido=distInicioFinalPredecido;
           	}
           }
       }

    	
    return mejorAnguloVertical;
    }
    
    private int [] getJugsPorDelante(int jugRem,int factorAdelante,SituacionPartido sp)
    {
    	int jugs[]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
    	int cont=0;
    	for (int i=0;i<11;i++)
    	{
    		if (sp.misJugadores()[i].getY()>sp.misJugadores()[jugRem].getY()+factorAdelante && i!=jugRem)
    		{
    			jugs[cont]=i;
    			cont++;
    		}
    	}

    return jugs;
    }
    
    private int buscarPaseClaro(int jugRem,int []jugsAPasar,SituacionPartido sp)
    {
    	int jugPaseClaro=-1;
    	int longitud=jugsAPasar.length;
    	int cont=0;
    	while (cont<longitud && jugsAPasar[cont]!=-1)
    	{
    		if (sp.balon().distancia(sp.misJugadores()[jugsAPasar[cont]])<25 && !this.esPosibleInterceptar(jugRem, sp.balon(), sp.misJugadores()[jugsAPasar[cont]], sp))
    		{
    			jugPaseClaro=jugsAPasar[cont];
       		}
    	cont++;
    	}
    	
    return jugPaseClaro;
    }
    
    private void tiroAjustadoPorteria(int jug,SituacionPartido sp)
    {
    	Posicion posPorteroCont=sp.rivales()[porteroContrario];
    	Posicion posJugTirar=sp.misJugadores()[jug];
    	
    	if (paseDelantero || (posJugTirar.getX())>-2 && posJugTirar.getX()<2)
    	{
    		buscarMejorDisparo(jug,sp);
    	}
    	else
    	{
    		if (posJugTirar.getX()<=-2)
    		{
    			if (posPorteroCont.getX()<=-2)
    			{
    				//pase al otro delantero
    				Posicion posAproxOtroDelantero=new Posicion(4,posJugTirar.getY());
    				int otroDelantero=posAproxOtroDelantero.indiceMasCercano(sp.misJugadores(),jug);
    				Posicion posExactOtroDelantero=sp.misJugadores()[otroDelantero];
    				comandos.add(new ComandoGolpearBalon(jug,posExactOtroDelantero,1,false));
    				paseDelantero=true;
    				this.itPaseDelantero=sp.iteracion();
    				
    			}
    			else
    			{
    				buscarMejorDisparo(jug,sp);
    			}
    			
    		}
    		else if (posJugTirar.getX()>=2)
    		{
    			if (posPorteroCont.getX()>=2)
    			{
    				//pase al otro delantero
    				Posicion posAproxOtroDelantero=new Posicion(-4,posJugTirar.getY());
    				int otroDelantero=posAproxOtroDelantero.indiceMasCercano(sp.misJugadores(),jug);
    				Posicion posExactOtroDelantero=sp.misJugadores()[otroDelantero];
    				comandos.add(new ComandoGolpearBalon(jug,posExactOtroDelantero,1,false));
    				paseDelantero=true;
    				this.itPaseDelantero=sp.iteracion();
    			}
    			else
    			{
    				buscarMejorDisparo(jug,sp);
    			}
    		}
    		
    	}

    	
    
    	

    }
    
    private void buscarMejorDisparo(int jug,SituacionPartido sp)
    {
    	double porteroX=sp.rivales()[porteroContrario].getX();
    	double jugadorX=sp.misJugadores()[jug].getX();
    	

    		if (porteroX>=1.5)
        	{
        		Posicion dispararA=new Posicion(-2.2,53);
        		comandos.add(new ComandoGolpearBalon(jug,dispararA,1,10));
        	}
        	else if(porteroX<=-1.5)
        	{
        		Posicion dispararA=new Posicion(2.2,53);
        		comandos.add(new ComandoGolpearBalon(jug,dispararA,1,10));
        	}
        	else
        	{
        		if (jugadorX>0)
        		{
        			Posicion dispararA=new Posicion(2.2,53);
            		comandos.add(new ComandoGolpearBalon(jug,dispararA,1,10));
        		}
        		else
        		{
        			Posicion dispararA=new Posicion(-2.2,53);
            		comandos.add(new ComandoGolpearBalon(jug,dispararA,1,10));
        		}
        	}    	
    	
    	
    }
    
    
    private boolean puedoLlevarBalon(int numJug,SituacionPartido sp)
    {
    	boolean puedoLLevar=true;
    	
    	double vel=Constantes.getVelocidad(sp.detalleMisJugadores()[numJug].getVelocidad())+.2;
    	Posicion laPosicionTiro=new Posicion(0,52.5);
    	double ang=sp.balon().angulo(laPosicionTiro);
    	double balonDistx = Math.cos(ang) * vel;
        double balonDisty = Math.sin(ang) * vel;
        
        double balonDxAcum=balonDistx;
        double balonDyAcum=balonDisty;
    	for (int i=0;i<10;i++)
    	{
    		balonDistx=balonDistx*Constantes.FACTOR_DISMINUCION_VEL_BALON_SUELO;
    		balonDisty=balonDisty*Constantes.FACTOR_DISMINUCION_VEL_BALON_SUELO;
    		
    		balonDxAcum=balonDxAcum+balonDistx;
    		balonDyAcum=balonDyAcum+balonDisty;
    	}
    	
    	Posicion posFinalBola=new Posicion(sp.balon().getX()+balonDxAcum,sp.balon().getY()+balonDyAcum);
    	double distJugadorBola=0;
    	for(int i=0;i<11 && puedoLLevar==true;i++)
    	{
    		distJugadorBola=sp.rivales()[i].distancia(posFinalBola);
    		if (Constantes.getVelocidad(sp.detalleJugadoresRivales()[i].getVelocidad())*13>distJugadorBola)
    		{
    			puedoLLevar=false;
    		}
    		
    	}
    	
    	
    return puedoLLevar;
    }
    
    private void moverBalon() {
    	
    	if (ballZAnterior==0 && ballDz>0 && ballDz < Constantes.G * 3)
    	{
           	ballDx = ballDx * Constantes.FACTOR_DISMINUCION_VEL_BALON_SUELO;
        	ballDy = ballDy * Constantes.FACTOR_DISMINUCION_VEL_BALON_SUELO;
        	ballX=ballX + ballDx;
        	ballY=ballY + ballDy;
    	}
    	else
    	{
            ballDz = redondeaMultiplo(ballDz - Constantes.G, Constantes.G);
    		ballDx = ballDx * Constantes.FACTOR_DISMINUCION_VEL_BALON_AIRE;
    		ballDy = ballDy * Constantes.FACTOR_DISMINUCION_VEL_BALON_AIRE;
        	ballX=ballX + ballDx;
        	ballY=ballY + ballDy;
    		
    		if (ballZ == 0) {
    			ballDz = (-ballDz - Constantes.G) * Constantes.FACTOR_DISMINUCION_ALTURA_BALON_REBOTE;
    			ballDz = redondeaMultiplo(ballDz, Constantes.G);
            }
    		ballZ = redondeaMultiplo(ballZ + ballDz, Constantes.G);
    	}
       
      
        
    }
    private double redondeaMultiplo(double valor, double divisor) {
        return Math.round(valor / divisor) * divisor;
    }
    
    private int moverJugadorAlBalon(SituacionPartido sp)
    {
    	int numJugador=0;
    	int bonus=1;
    	ballX=sp.balon().getX();
    	ballY=sp.balon().getY();
    	ballZ=sp.alturaBalon();
    	ballZAnterior=this.posAntZ;
    	ballDx=this.balonDx;
    	ballDy=this.balonDy;
    	ballDz=this.balonDz;
    	
    	boolean llegoAlBalon=false;
    	
    	while (!llegoAlBalon && bonus<=300)
    	{
    		moverBalon();
    		ballZAnterior=sp.alturaBalon();
    		if (ballZ<=Constantes.ALTURA_CONTROL_BALON)
    		{
    			boolean encontrado=false;
    			int cont=0;
    			Posicion posicionBola=new Posicion(ballX,ballY);
    			while(!encontrado && cont<11)
    			{
    				double dist=sp.misJugadores()[cont].distancia(posicionBola);
    				double velocidadJugador=Constantes.getVelocidad(sp.detalleMisJugadores()[cont].getVelocidad());
    				/*if(cont==10)//mi portero
    				{
    					Posicion posFinalBola=new Posicion(ballX,ballY);
    			    	double distContrarioBola=0;
    			    	boolean salgo=true;
    			    	for(int i=0;i<11 && salgo==true;i++)
    			    	{
    			    		distContrarioBola=sp.rivales()[i].distancia(posFinalBola);
    			    		if (Constantes.getVelocidad(sp.detalleJugadoresRivales()[i].getVelocidad())*bonus>distContrarioBola)
    			    		{
    			    			salgo=false;
    			    		}
    			    		
    			    	}
    			    	if (salgo==true)
    			    	{
    			    		if (dist<=velocidadJugador*bonus)
            				{
            					numJugador=cont;
            					encontrado=true;
            					llegoAlBalon=true;
            				}
    			    	}
		
           			}
    				else
    				{*/
        				if (dist<=velocidadJugador*bonus+Constantes.DISTANCIA_CONTROL_BALON)
        				{
        					if (cont!=10 || (cont==10 && ballY<-41 && ballX<13 && ballX>-13))
        					numJugador=cont;
        					encontrado=true;
        					llegoAlBalon=true;
        				}
    				//}

    			cont++;
    			}
    		}
    	
    	bonus++;
    	}
    	
    	return numJugador;   	
    	
    }
    
    private void paseDeDefensa(int jug,SituacionPartido sp)
    {
    	Posicion posBola=sp.balon();
    	int [] jugPosiblesAPasar=new int [7];
    	int cont=0;
    	
    	Posicion posJugPase=sp.misJugadores()[0]; //el delantero se trata a parte pk es el num 0
    	if(posBola.distancia(posJugPase) <35)
    	{
    		jugPosiblesAPasar[cont]=0;
    		cont++;
    	}
    	
    	for (int i=4;i<10;i++)
    	{
    		posJugPase=sp.misJugadores()[i];
    		if(posBola.distancia(posJugPase) <35)
        	{
        		jugPosiblesAPasar[cont]=i;
        		cont++;
        	}
    	}
    	
    	//ya estan metido en el array los jugadores que no estan muy lejos del balon
    	
    	if (cont>0)
    	{
    		double distanciaMinima=300;
    		int jugAPasar=-1;
    		cont--;
    		while (cont>=0)
    		{
    			if (!esPosibleInterceptar (jug,sp.balon(),sp.misJugadores()[jugPosiblesAPasar[cont]],sp))
    			{
    				if (sp.balon().distancia(sp.misJugadores()[jugPosiblesAPasar[cont]])<distanciaMinima)
    				{
    					distanciaMinima=sp.balon().distancia(sp.misJugadores()[jugPosiblesAPasar[cont]]);
    					jugAPasar=jugPosiblesAPasar[cont];
    				}
    			}
    		cont--;
    		}
    		if (jugAPasar==-1)
    		{
    			int [] jugsPosiblesAPasar={0,2,4,5,6,7,8,9};
    			jugAPasar=jugadorConContrarioMasLejano(jugsPosiblesAPasar, sp);
    			comandos.add(new ComandoGolpearBalon(jug,sp.misJugadores()[jugAPasar],1,45));
    			
    		}
    		else
    		{
    			comandos.add(new ComandoGolpearBalon(jug,sp.misJugadores()[jugAPasar],1,45));
    		}
    	}
    	else
    	{
    		int [] jugsPosiblesAPasar={0,2,4,5,6,7,8,9};
			int jugAPasar=jugadorConContrarioMasLejano(jugsPosiblesAPasar, sp);
			comandos.add(new ComandoGolpearBalon(jug,sp.misJugadores()[jugAPasar],1,45));
    	}
    }
    
    private List<Comando> moverJugadoresEnFuncionBalon(SituacionPartido sp,List<Comando> comandos)
    {
    	double balonX=sp.balon().getX();
    	double balonY=sp.balon().getY();
    	
    	double coenfAdX=balonX;
        double coenfAdY=balonY;
        
        Posicion kontrakoAtezaina=sp.rivales()[this.porteroContrario];
        
        
        Posicion posicionesActuales[]={
        		new Posicion (this.control(7+coenfAdX,1,12),this.control(27+coenfAdY,-5,44)), //delantero derecha,
                new Posicion (this.control(-6+coenfAdX,-25,5),this.control(-26+coenfAdY,-45,0)),  //central izq
                new Posicion (this.control(-kontrakoAtezaina.getX(),-3.3,3.3),this.control(kontrakoAtezaina.getY()-4,40,50)),  // delantero centro
                new Posicion (this.control(6+coenfAdX,-5,25),this.control(-26+coenfAdY,-47,-10)),   //central derecho
                new Posicion (this.control(6+coenfAdX,-9,15),this.control(-4+coenfAdY,-29,23)),  //  pivote derecha
                new Posicion (this.control(-6+coenfAdX,-15,9),this.control(-4+coenfAdY,-22,23)),  //  pivote izquierda
                new Posicion (this.control(-20+coenfAdX,-30,0),this.control(3+coenfAdY,-22,40)),  //  interior izquierda
                new Posicion (this.control(20+coenfAdX,0,30),this.control(3+coenfAdY,-22,40)),  //  interior derehca
                new Posicion (this.control(-7+coenfAdX,-12,-1),this.control(27+coenfAdY,-5,44)),  //  delantero izquierdo
                new Posicion (this.control(-3+coenfAdX,-15,15),this.control(12+coenfAdY,-13,36)), // media punta
                new Posicion (this.control(sp.balon().getX(),-(Constantes.LARGO_ARCO / 2)+1.3,(Constantes.LARGO_ARCO / 2)-1.3),-52) }; //  PORTERO
        
        if (sp.balon().getX()<-12)
        {
        	posicionesActuales[1]=new Posicion (this.control(-6+coenfAdX,sp.balon().getX()+1,5),this.control(-26+coenfAdY,-45,0));
        }
        if (sp.balon().getX()>12)
        {
        	posicionesActuales[3]=new Posicion (this.control(6+coenfAdX,-5,sp.balon().getX()-1),this.control(-26+coenfAdY,-47,-10));
        }

        for (int n=0 ; n<11 ; n++)
        { 
        	comandos.add(new ComandoIrA(n,posicionesActuales[n]));
        }
        
           
    	
    return comandos;
    }    
    
   
    private void paseDePortero(SituacionPartido sp)
    {
    	Posicion medio1=sp.misJugadores()[4];
    	Posicion medio2=sp.misJugadores()[5];
    	double Xmedia=(medio1.getX()+medio2.getX())/2;
    	double Y=0;
    	if (medio1.getY()>=medio2.getY())
    	{
    		Y=medio1.getY();
       	}
    	else
    	{
    		Y=medio2.getY();	
    	}
    	
    	comandos.add(new ComandoGolpearBalon(10,new Posicion(Xmedia,Y),1,55));
    	

    }
    private double control(double numero, double min, double max){

        if (numero<min) return min;
        if (numero>max) return max;
        return numero;
    }
    
    private int jugadorConContrarioMasLejano(int [] arrayJugadores,SituacionPartido sp)
    {
    	int jug=-1;
    	double distanciaMaxima=-5;
    	
    	int cont=arrayJugadores.length;
    	for (int i=0; i<cont;i++)
    	{
    		Posicion posJug=sp.misJugadores()[arrayJugadores[i]];
    		int contrarioMasCercano=posJug.indiceMasCercano(sp.rivales());
    		Posicion posContrario=sp.rivales()[contrarioMasCercano];
    		if (posJug.distancia(posContrario)>distanciaMaxima)
    		{
    			jug=arrayJugadores[i];
    			distanciaMaxima=posJug.distancia(posContrario);
    		}
    	}
    	
    return jug;
    }
    
    private boolean esPosibleInterceptar(int jug,Posicion posIni,Posicion posFinal,SituacionPartido sp)
    {
    	
    	double iniX=posIni.getX();
    	double iniY=posIni.getY();
    	
    	double vel=1*Constantes.getVelocidadRemate(sp.detalleMisJugadores()[jug].getRemate());
    	double angHoriz=posIni.angulo(posFinal);
    	Posicion [] rivales=sp.rivales();
    	
    	double distanX=Math.cos(angHoriz) * vel;
    	double distanY=Math.sin(angHoriz) * vel;
    	double nuevaPosX=iniX+distanX;
    	double nuevaPosY=iniY+distanY;
    	Posicion nuevaPos=new Posicion(nuevaPosX,nuevaPosY);
    	int bonus=1;
    	boolean llegaContrario=false;
    	while (distanY>0.2 && nuevaPos.distancia(posFinal)>1 && !llegaContrario)
    	{
    		distanX=distanX * Constantes.FACTOR_DISMINUCION_VEL_BALON_SUELO;
    		distanY=distanY * Constantes.FACTOR_DISMINUCION_VEL_BALON_SUELO;
    		nuevaPosX=nuevaPosX+distanX;
    		nuevaPosY=nuevaPosY+distanY;
    		nuevaPos=new Posicion(nuevaPosX,nuevaPosY);
    		
    		for(int i=0;i<10 && !llegaContrario;i++)
    		{
    			Posicion posContrario=rivales[i];
    			double distBalonContrario=posContrario.distancia(nuevaPos);
    			if (distBalonContrario<((Constantes.getVelocidad(sp.detalleJugadoresRivales()[i].getVelocidad())*bonus)+Constantes.DISTANCIA_CONTROL_BALON))
    			{
    				llegaContrario=true;
    			}
    		}
    		
    		
    	bonus++;
    	}
    	
    	
    	
    return llegaContrario;
    }
    

}